/*
 * @Description: 图片处理
 * @Author: cy
 * @Date: 2024/5/31
 */
const express = require("express");
//图片处理
const sharp = require("sharp");
const router = express.Router();
const fs = require("fs");
const { removeBackgroundFromImageFile } = require("remove.bg");

const Jimp = require("jimp");

// 去除水印的函数
const removeWatermark = (imagePath, watermarkPath, outputPath) => {
  Jimp.read(imagePath)
    .then((image) => {
      // 读取水印图片
      return Jimp.read(watermarkPath).then((watermark) => {
        // 获取水印图片的大小
        const { width, height } = watermark.bitmap;
        // 遍历主图片中的每个像素，尝试匹配水印
        image.scan(
          0,
          0,
          image.bitmap.width,
          image.bitmap.height,
          function (x, y, idx) {
            // 提取当前像素的颜色
            const r = this.bitmap.data[idx + 0];
            const g = this.bitmap.data[idx + 1];
            const b = this.bitmap.data[idx + 2];
            // 对比当前像素与水印图片的颜色
            watermark.scan(0, 0, width, height, function (wx, wy, widx) {
              const wr = this.bitmap.data[widx + 0];
              const wg = this.bitmap.data[widx + 1];
              const wb = this.bitmap.data[widx + 2];
              // 如果发现相同颜色，则认为是水印，将其变透明
              if (r === wr && g === wg && b === wb) {
                this.bitmap.data[idx + 3] = 0; // 设置透明度为0
              }
            });
          }
        );
        // 保存处理后的图片
        return image.write(outputPath);
      });
    })
    .catch((err) => {
      console.error(err);
    });
};

//函数要求对文件夹下文件进行重新命名，名称规则为1.png递增，2.png递增，3.png递增，以此类推
const renameFile = (inputDir, outputDir) => {
  try {
    // 检查输入目录是否存在
    if (!fs.existsSync(inputDir)) {
      console.error(`输入目录不存在: ${inputDir}`);
      return;
    }

    // 确保输出目录存在
    if (!fs.existsSync(outputDir)) {
      console.log(`创建输出目录: ${outputDir}`);
      fs.mkdirSync(outputDir, { recursive: true });
    }

    const files = fs.readdirSync(inputDir);
    console.log(`在目录 ${inputDir} 中找到 ${files.length} 个文件`);

    files.forEach((file, index) => {
      try {
        // 跳过隐藏文件
        if (file.startsWith(".")) {
          console.log(`跳过隐藏文件: ${file}`);
          return;
        }

        const currentPath = `${inputDir}/${file}`;

        //判断是不是文件夹
        if (fs.statSync(currentPath).isDirectory()) {
          console.log(`处理子目录: ${currentPath}`);
          //递归调用
          renameFile(currentPath, outputDir);
        } else {
          //每隔25个文件，重命名一次，比如第26文件，重命名成1-1.png，第51文件，重命名成2-1.png，以此类推
          const newName = `${Math.floor(index / 25) + 1}-${
            (index % 25) + 1
          }-${Math.random().toString(36).substring(2, 15)}.png`;

          console.log(`重命名文件: ${file} -> ${newName}`);
          fs.renameSync(currentPath, `${outputDir}/${newName}`);
        }
      } catch (fileError) {
        console.error(`处理文件 ${file} 时出错:`, fileError);
      }
    });
  } catch (error) {
    console.error("重命名过程中发生错误:", error);
  }
};

//renameFile1
const renameFile1 = (inputDir, outputDir) => {
  const files = fs.readdirSync(inputDir);
  files.forEach((file, index) => {
    //重新命名,1.png,2.png依次类推
    const newName = `${index + 1}.png`;
    fs.renameSync(`${inputDir}/${file}`, `${outputDir}/${newName}`);
  });
};

// 修改路由处理函数，添加错误处理
router.get("/renameFile", (req, res) => {
  try {
    const inputDir = "/Users/chaoyang/Downloads/Google/newzip";
    const outputDir = "/Users/chaoyang/Downloads/Google/zip1";

    console.log("开始重命名文件...");
    console.log(`输入目录: ${inputDir}`);
    console.log(`输出目录: ${outputDir}`);

    renameFile1(inputDir, outputDir);
    res.json({ success: true, message: "重命名成功" });
  } catch (error) {
    console.error("路由处理错误:", error);
    res.status(500).json({
      success: false,
      message: "重命名失败",
      error: error.message,
    });
  }
});

// 更新路由处理函数-抠图-remove.bg
router.get("/removeImg", async (req, res) => {
  try {
    const inputPath = `/Users/chaoyang/cy/image/phoneImg/孙大聪明/孙晓伦2.jpeg`;
    const outputPath = `/Users/chaoyang/cy/image/phoneImg/孙大聪明无背景/孙晓伦2.jpeg`;
    removeBackgroundFromImageFile({
      path: inputPath,
      apiKey: "ZfarxXECmv53eu5WYLD1tpt3",
      size: "full",
      type: "person",
      scale: "100%",
      outputFile: outputPath,
    })
      .then((result) => {
        console.log(`File saved to ${outputFile}`);
        const base64img = result.base64img;
      })
      .catch((errors) => {
        console.log(JSON.stringify(errors));
      });
    res.json({ success: true, message: "抠图处理成功" });

    // 图片文件夹路径
    let inputDir = "/Users/chaoyang/cy/image/phoneImg/孙大聪明";
    let outputDir = "/Users/chaoyang/cy/image/phoneImg/孙大聪明无背景";
    const files = fs.readdirSync(inputDir);
    // 遍历文件夹中的每个文件
    files.forEach((file) => {
      // 检查文件是否为图片,排除以.开头的文件，例如 .DS_Store
      if (!file.startsWith(".")) {
        // 构建输入和输出路径
        const inputPath = `${inputDir}/${file}`;
        const outputPath = `${outputDir}/${file}`;
        // 抠图
        console.log(inputPath, outputPath);
      }
    });
  } catch (error) {
    res.status(500).json({
      success: false,
      message: error.message,
    });
  }
});

function compressImage(inputPath, outputPath, quality) {
  sharp(inputPath)
    //  设置图片大小
    // .resize(1000, 1000)
    // .composite([{ input: inputPath, gravity: 'south' }])
    // .extract({ width: watermarkText.length * 20, height: 20,left:0,top:0 }) // 假设字体大小是20px
    .jpeg({ quality })
    .toFile(outputPath, (err, info) => {
      if (err) {
        console.error("Error compressing image:", err);
      } else {
        console.log("Image compressed successfully:", info);
      }
    });
}

// 压缩图片
router.get("/", (req, res) => {
  // 图片文件夹路径
  let inputDir = "/Users/chaoyang/cy/image/desk";
  let outputDir = "/Users/chaoyang/cy/image/desk压缩";
  const files = fs.readdirSync(inputDir);
  // 遍历文件夹中的每个文件
  files.forEach((file) => {
    // 检查文件是否为图片,排除以.开头的文件，例如 .DS_Store
    if (!file.startsWith(".")) {
      // 构建输入和输出路径
      const inputPath = `${inputDir}/${file}`;
      const outputPath = `${outputDir}/${file}`;
      // 压缩图片
      compressImage(inputPath, outputPath, 100);
    }
  });
  return res.json({});
});

//水印处理
router.get("/watermark", (req, res) => {
  const inputPath = "/Users/chaoyang/cy/ps/1.png";
  const outputPath = "/Users/chaoyang/cy/ps/1-副本.png";
  const watermarkText = "VIP可无水印保存";
  // 创建水印SVG
  const svg = `
   <svg width="1000" height="300" xmlns="http://www.w3.org/2000/svg">
     <text x="50%" y="50%" 
           font-family="Arial" 
           font-size="100" 
           fill="rgba(255,255,255,0.5)" 
           text-anchor="middle" 
           dominant-baseline="middle">
       ${watermarkText}
     </text>
   </svg>
 `;
  const svgBuffer = Buffer.from(svg);

  sharp(inputPath)
    //  设置图片大小
    // .resize(3840, 2160)
    .composite([
      {
        input: svgBuffer,
        gravity: "southeast",
        blend: "over",

        tile: true,
      },
    ])
    // .extract({ width: watermarkText.length * 20, height: 20, left: 0, top: 0 }) // 假设字体大小是20px
    .jpeg({ quality: 30 })
    .toFile(outputPath, (err, info) => {
      if (err) {
        console.error("Error compressing image:", err);
      } else {
        console.log("Image compressed successfully:", info);
      }
    });
  res.json({});
});

module.exports = router;
